 
 //测试完毕， 4个参数都成功
/*
  options中的几种属性：
    one： 回调函数只执行一次
    memory: 记忆，用于触发语句在添加回调前的情况
    stopOnFalse： 函数返回false，终止操作
    unique: 唯一的，相同函数只能添加1次
*/

 var callbackState = {}

  var createCallbackState = function (options) {
    var states = options.split(' ')
    var obj = {}
    for (var i = 0; i < states.length; i++) {
      obj[states[i]] = true
    }
    return obj
  }

  var Callback = function (options) {

    var state = callbackState[options]  //获取模式
    if (!state) {
      callbackState[options] = state = createCallbackState(options)
    }
    var list = [],
      memory,
      has = function (fn) {
        for (var i = 0; i < list.length; i++) {
          if (list[i] === fn) {
            return true
          }
        }
        return false
      },
      add = function () {
        var i = 0,
          args = arguments,
          len = args.length
        for (; i < len; i++) {
          if (state.unique && has(args[i])) {
            continue
          }
          list.push(args[i])
        }
      },
      fire = function (context, args) {
        var i = 0,
          len = list.length,
          item
        for (; i < len; i++) {
          item = list[i]
          if (item.apply(context,args) === false && state.stopOnFalse) {
            break;
          }
        }
      }

    return {
      add: function () {
        add.apply(null,arguments)
        // 如果memory模式并且已经拥有了memory信息，接着出发函数
        if (state.memory && memory) {
          fire(memory[0], memory[1])
          list = []
        }
      },
      fire: function (context, args) {
        // 如果memory模式，并且list是空，代表触发在添加前，保存memory信息
        if (state.memory && !list.length) {
          memory = [context, args]
          return
        }
        fire(context,args)
        if (state.one) {
          this.clear()
        }
      },
      has: function (fn) {
        return has(fn)
      },
      clear: function () {
        list = []
      }
    }

  }